const { Collect, CollectType, User } = require('../models/Middle')
const { Op } = require('sequelize')
const moment = require('moment')
const seq = require('../utils/seq')
const AppRes = require('../config/app.res')

// 新增
async function add (collectType) {
  collectType.ctime = moment().format('YYYY-MM-DD HH:mm:ss')
  collectType.mtime = moment().format('YYYY-MM-DD HH:mm:ss')
  try {
    return await CollectType.create(collectType)
  } catch (error) {
    throw error
  }
}

// 查询（分页、排序、模糊查询搜索、查询状态）
/**
 * limit 提取多少行，offset 跳过多少行
 * @param {*} page 当前页码
 * @param {*} size 每页条数
 */
async function findAll (query, uid) {
  try {
    const size = query.size ? parseInt(query.size) : 10 // 如果没传参数设置一个默认值
    const page = query.page ? parseInt(query.page) : 1
    const { count, rows } = await CollectType.findAndCountAll({
      include: {
        model: User
      },
      where: {
        uid,
        status: {
          [Op.like]: query.status ? `%${JSON.parse(query.status) ? 1 : 0}%` : '%%' // 查询状态
        },
        [Op.or]: [ // 模糊查询
          { name: { [Op.like]: query.search ? `%${query.search}%` : '%%' } },
          { remark: { [Op.like]: query.search ? `%${query.search}%` : '%%' } },
          { ctime: { [Op.like]: query.search ? `%${query.search}%` : '%%' } },
          { mtime: { [Op.like]: query.search ? `%${query.search}%` : '%%' } }
        ],
      },
      offset: (page - 1) * size,
      limit: size,
      distinct: true, // 避免分页出的总数和实际数不匹配
      order: [
        [query.order ? query.order : 'ctime', query.sort ? query.sort : 'desc'] // 使用 Element 表格中的排序是互斥的，所以每次排序只能排一个元素的
      ]
    })
    return {
      count,
      data: rows
    }
  } catch (error) {
    throw error
  }
}

// 修改
async function update (collectType, uid) {
  collectType.mtime = moment().format('YYYY-MM-DD HH:mm:ss')
  try {
    if (collectType.uid === uid) {
      return CollectType.update(collectType, {
        where: {
          id: collectType.id,
          uid
        }
      })
    } else {
      return AppRes['401']
    }
  } catch (error) {
    throw error
  }
}


/**删除
 * 分两种情况：1.将该类别下的收藏移动到其他类别中，然后删除该类别；2.一并删除（收藏和收藏类别全都删除）
 * 删除类别（uid, tid）-> 根据uid和tid找到包含的收藏列表，修改这些收藏列表的类别，最后根据uid和tid删除该类别
 * 一并删除，先根据uid和tid删除收藏，在根据uid和tid删除类别
 * @param {*} id 删除的类别id
 * @param {*} uid 用户id
 * @param {*} status 删除类型
 * @param {*} type 前端传过来的移动的类别id
 * @returns 
 */
async function deleteById (id, uid, status, type) {
  try {
    if (status === 'move') {
      const [results, metadata] = await seq.query(`select * from collect where uid='${uid}' and tid='${id}'`)
      results.forEach(async item => {
        await seq.query(`update collect set tid='${type}' where uid='${uid}' and id='${item.id}'`)
      })
    } else {
      await seq.query(`delete from collect where uid='${uid}' and tid='${id}'`)
    }
    const res = await CollectType.findOne({
      where: { id }
    })
    if (res.uid === uid) {
      return await CollectType.destroy({
        where: {
          id,
          uid
        }
      })
    } else {
      return AppRes['401']
    }
  } catch (error) {
    throw error
  }
}

// 根据id查询
async function findOneById (id) {
  try {
    return await CollectType.findOne({
      include: {
        model: User
      },
      where: {
        id
      }
    })
  } catch (error) {
    throw error
  }
}

// 根据用户id查询类别列表
async function findCollectTypesById (uid) {
  try {
    return await CollectType.findAll({
      where: {
        uid
      }
    })
  } catch (error) {
    throw error
  }
}

module.exports = {
  add,
  findAll,
  update,
  deleteById,
  findOneById,
  findCollectTypesById
}